﻿using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;

namespace Com.JunCaiSoft.Common.AssistClass
{
    public class DateTimeExtension
    {
        /// 创建一个DateTime
        public static DateTime dt = dt;
        static DateTimeExtension instance = null;
        //创建一个对象
        private static readonly object lockObj = new object();
        public DateTimeExtension()
        {
            //System.Globalization.CultureInfo cultureInfo = new System.Globalization.CultureInfo("zh-CN", true);
            //cultureInfo.DateTimeFormat.ShortDatePattern = "yyyy-MM-dd";
            //cultureInfo.DateTimeFormat.FullDateTimePattern = "yyyy-MM-dd HH:mm:ss";
            //System.Threading.Thread.CurrentThread.CurrentCulture = cultureInfo;

        }
        /// <summary>
        /// 单例模式
        /// </summary>
        /// <returns></returns>
        public static DateTimeExtension GetInstance()
        {
            //lock (AccessFileHelper.instance){ }
            if (instance == null)
            {
                lock (lockObj)
                {
                    instance = new DateTimeExtension();
                }
            }
            return instance;
        }
        /// <summary>
        /// 纯粹返回一个string的DateTime
        /// </summary>
        /// <returns>返回结果如2012-8-10 12:47:04 </returns>
        public static string GetDateTimeNow()
        {
            return dt.ToString();
        }
        /// <summary>
        /// 返回一个string字符串的时间
        /// </summary>
        /// <returns> 返回结果如: 2012-8-10 13:21:25 </returns>
        public static string GetString_DateTime()
        {
            return dt.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToFileTime方法
        /// ToFileTime这个是返回一个long类型
        /// </summary>
        /// <returns>返回结果如: 127756416859912816 </returns>
        public static string GetToFile_DateTime()
        {
            return dt.ToFileTime().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToFileTimeUtc方法
        /// ToFileTimeUtc这个是返回一个long类型
        /// </summary>
        /// <returns>返回结果如:127756704859912816 </returns>
        public static string GetToFileUtc_DateTime()
        {
            return dt.ToFileTimeUtc().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToLocalTime方法
        /// </summary>
        /// <returns>返回结果如:2012-8-10 21:21:25 </returns>
        public static string GetToLocalDate_DateTime()
        {
            return dt.ToLocalTime().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToLongDateString方法
        /// </summary>
        /// <returns>返回一个格式为：2012年8月10日</returns>
        public static string GetToLongDateStr_DateTime()
        {
            return dt.ToLongDateString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToLongTimeString方法
        /// </summary>
        /// <returns>返回结果如：13:21:25 </returns>
        public static string GetToLongTimeStr_DateTime()
        {
            return dt.ToLongTimeString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToOADate方法
        /// </summary>
        /// <returns>返回结果如:38661.5565508218 </returns>
        public static string GetToOADate_DateTime()
        {
            return dt.ToOADate().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToShortDateString方法
        /// 得到今天ToDay
        /// </summary>
        /// <returns>返回结果如：2012-8-10 </returns>
        public static string GetToShortDateStr_ToDay()
        {
            //return dt.ToShortDateString().ToString();
            return dt.Date.ToShortDateString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToShortDateString方法
        /// 得到昨天Yesterday
        /// </summary>
        /// <returns>返回结果如：2012-8-10 </returns>
        public static string GetToShortDateStr_Yesterday()
        {
            return dt.Date.AddDays(-1).ToShortDateString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToShortDateString方法
        /// 得到明天Tomorrow
        /// </summary>
        /// <returns>返回结果如：2012-8-10 </returns>
        public static string GetToShortDateStr_Tomorrow()
        {
            return dt.Date.AddDays(1).ToShortDateString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToShortDateString方法
        /// </summary>
        /// <returns>返回结果如: 13:21 </returns>
        public static string GetToShortTimeStr_DateTime()
        {
            return dt.ToShortTimeString().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的ToUniversalTime方法
        /// </summary>
        /// <returns>返回结果如：2012-8-10 5:21:25</returns>
        public static string GetToUniversalTime_DateTime()
        {
            return dt.ToUniversalTime().ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的封装类Year类
        /// </summary>
        /// <returns>返回结果如：2012</returns>
        public static string GetYear()
        {
            return dt.Year.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的Date
        /// </summary>
        /// <returns>返回结果如：2012-8-12 0:00:00</returns>
        public static string GetDate()
        {
            return dt.Date.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的一周的星期几
        /// DayOfWeek是一个枚举
        /// </summary>
        /// <returns>返回结果如：FriDay </returns>
        public static string GetDayOfWeek()
        {
            return dt.DayOfWeek.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的DayOfYear
        /// DayOfYear是一个枚举
        /// </summary>
        /// <returns>返回结果如:309  </returns>
        public static string GetDayOfYear()
        {
            return dt.DayOfYear.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime里面的小时
        /// 小时组成部分，表示为 0 和 23 之间的一个值。
        /// </summary>
        /// <returns>返回结果如:12</returns>
        public static string GetHour()
        {
            return dt.Hour.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的毫秒
        /// 毫秒组成部分，表示为 0 和 999 之间的一个值.
        /// </summary>
        /// <returns>返回结果如:120</returns>
        public static string GetMillisecond()
        {
            return dt.Millisecond.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的分钟
        /// 分钟组成部分，表示为 0 和 59 之间的一个值.
        /// </summary>
        /// <returns>返回结果如:23</returns>
        public static string GetMinute()
        {
            return dt.Minute.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的月份
        /// 月组成部分，表示为 1 和 12 之间的一个值。
        /// </summary>
        /// <returns>返回结果如:8</returns>
        public static string GetMonth()
        {
            return dt.Month.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的秒数
        /// 秒数(介于 0 和 59 之间).
        /// </summary>
        /// <returns>返回结果如:12</returns>
        public static string GetSecond()
        {
            return dt.Second.ToString();
        }
        /// <summary>
        /// 此方法封装处理DateTime的周期数
        /// 表示此实例的日期和时间的计时周期数
        /// 该值介于 DateTime.MinValue.Ticks 和 DateTime.MaxValue.Ticks
        /// </summary>
        /// <returns>返回结果如:632667942284412864 </returns>
        public static string GetTicks()
        {
            return dt.Ticks.ToString();
        }
        /// <summary>
        ///  System.TimeSpan它表示当天自午夜以来已经过时间的部分。
        /// </summary>
        /// <returns>返回结果如:13:30:28.4412864</returns>
        public static string GetTimeOfDay()
        {
            return dt.TimeOfDay.ToString();
        }
        /// <summary>
        /// 此方法封装获取明年当前时间.
        /// 说白就是在本年添加一
        /// </summary>
        /// <returns>返回的结果如：2013-11-5 13:47:04</returns>
        public static string GetAddOneYears()
        {
            return dt.AddYears(1).ToString();
        }
        /// <summary>
        /// 此方法在当天添加1.1Day
        /// 可能会出现异常 System.ArgumentOutOfRangeException:
        /// </summary>
        /// <returns>返回的结果如:2012-8-11 16:11:04 </returns>
        public static string GetAddDays()
        {
            try
            {
                return dt.AddDays(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 此方法在当前时间添加1.1个小时
        ///可能会出现异常 System.ArgumentOutOfRangeException:
        /// </summary>
        /// <returns>返回的结果如:2012-8-10 16:11:04 </returns>
        public static string GetAddHours()
        {
            try
            {
                return dt.AddHours(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 此方法在当前时间添加1.1毫秒
        /// 可能会出现异常 System.ArgumentOutOfRangeException:
        /// </summary>
        /// <returns></returns>
        public static string GetAddMilliseconds()
        {
            try
            {
                return dt.AddMilliseconds(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///在当前月添加一个月
        ///异常:System.ArgumentOutOfRangeException:
        ///所生成的 System.DateTime 小于 System.DateTime.MinValue 或大于 System.DateTime.MaxValue。
        ///- 或 - months 小于 -120,000 或大于 120,000。
        /// </summary>
        /// <returns>返回的结果如:2012-08-11 13:47:04 </returns>
        public static string GetAddMonths()
        {
            try
            {
                return dt.AddMonths(1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 在当前秒数基础上添加一1.1秒数
        /// System.ArgumentOutOfRangeException:
        /// </summary>
        /// <returns>2012-08-10 13:47:05 </returns>
        public static string GetAddSeconds()
        {
            try
            {
                return dt.AddSeconds(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 在当前时间上添加1.1分钟
        /// </summary>
        /// <returns></returns>
        public static string GetAddMinutes()
        {
            try
            {
                return dt.AddMinutes(1.1).ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 将指定1000的计时周期数加到此实例的值上
        /// </summary>
        /// <returns></returns>
        public static string GetAddTicks()
        {
            try
            {
                return dt.AddTicks(1000).ToString();//2005-11-5 13:47:04 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 比较时间
        /// 有符号数字，指示此实例和 value 参数的相对值 值 说明 小于零 此实例早于 value.
        /// 零 此实例与 value 相同.大于零 此实例晚于
        /// </summary>
        /// <param name="dateTime"></param>
        /// <returns></returns>
        public static string GetCompareTo(DateTime dateTime)
        {
            return dt.CompareTo(dateTime).ToString();
        }
        /// <summary>
        /// 指定时间判断是否相等
        /// </summary>
        /// <param name="dateTime">该值指示此实例是否与指定的对象相等</param>
        /// <returns>返回的结果:true/false</returns>
        public static string GetEquals(string dateTime)
        {
            return dt.Equals(dateTime).ToString();
        }
        /// <summary>
        /// 获取一个GetHashCode字符串
        /// </summary>
        /// <returns></returns>
        public static string GetHashCode_DateTime()
        {
            return dt.GetHashCode().ToString();//1474088234 
        }
        /// <summary>
        /// 获取当前时间类型
        /// </summary>
        /// <returns></returns>
        public static string GetDateTimeType()
        {
            return dt.GetType().ToString();//System.DateTime 
        }
        /// <summary>
        /// 获取当前时间类型码
        /// </summary>
        /// <returns></returns>
        public static string GetDateTimeTypeCode()
        {
            return dt.GetTypeCode().ToString();//System.DateTime 
        }
        /**
            * ============================GetDateTimeFormats处理DateTime============================
            */
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>返回结果如：2012-08-10T14:06:25 </returns>
        public static string GetDateTimeFormats_S()
        {
            try
            {
                return dt.GetDateTimeFormats('s')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        /// System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// <returns>返回结果如：14:06  </returns>
        ///</summary>
        public static string GetDateTimeFormats_T()
        {
            try
            {
                return dt.GetDateTimeFormats('t')[0].ToString();//14:06 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        /// System.FormatException:
        /// format 不是有效的标准日期和时间格式说明符。
        ///  </summary>
        /// <returns>返回结果如：2012年08月  </returns>
        public static string GetDateTimeFormats_Y()
        {
            try
            {
                return dt.GetDateTimeFormats('y')[0].ToString();//
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        /// format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>返回结果如：2012年08月10日</returns>
        public static string GetDateTimeFormats_D_Index0()
        {
            try
            {
                return dt.GetDateTimeFormats('D')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        /// format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>返回结果如：2012年08月10日</returns>
        public static string GetDateTimeFormats_D_Index1()
        {
            try
            {
                return dt.GetDateTimeFormats('D')[1].ToString();//2005 11 05 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///  format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>返回结果如：星期六 2012 08 10 </returns>
        public static string GetDateTimeFormats_D_Index2()
        {
            try
            {
                return dt.GetDateTimeFormats('D')[2].ToString();//2005 11 05 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>/星期六 2012年08月10日 </returns>
        public static string GetDateTimeFormats_D_Index3()
        {
            try
            {
                return dt.GetDateTimeFormats('D')[3].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>//08月10日  </returns>
        public static string GetDateTimeFormats_M()
        {
            try
            {
                return dt.GetDateTimeFormats('M')[0].ToString();//11月5日 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///  将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///  System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>2012年08月10日 14:06  </returns>
        public static string GetDateTimeFormats_F()
        {
            try
            {
                return dt.GetDateTimeFormats('f')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        /// System.FormatException:
        /// format 不是有效的标准日期和时间格式说明符。
        /// </summary>
        /// <returns>Result Example:2012-08-10 14:06 </returns>
        public static string GetDateTimeFormats_G()
        {
            try
            {
                return dt.GetDateTimeFormats('g')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        ///将此实例的值转换为指定的标准 System.DateTime 格式说明符支持的所有字符串表示形式。
        ///System.FormatException:
        ///format 不是有效的标准日期和时间格式说明符。
        ///</summary>
        /// <returns>Result Example:Fri,10 Aug 2010 14:06:25 GMT</returns>
        public static string GetDateTimeFormats_R()
        {
            try
            {
                return dt.GetDateTimeFormats('r')[0].ToString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /**
            *====================================GetFromat处理DateTime=============================
            * 
            */
        /// <summary>
        /// 异常:
        ///System.ArgumentNullException:
        ///format 为 null
        ///System.FormatException:
        ///format 中的格式项无效 - 或 - 用来表示要格式化的参数的数字小于零或者大于等于要格式化的指定对象的数目。
        /// </summary>
        /// <returns>result:2012-08-10 14:23:23 </returns>
        public static string GetFromat()
        {
            try
            {
                //return string.Format("{0}", dt);//效果一样
                return dt.ToString("{0}", DateTimeFormatInfo.InvariantInfo);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 异常:
        ///System.ArgumentNullException:
        ///format 为 null
        ///System.FormatException:
        ///format 中的格式项无效 - 或 - 用来表示要格式化的参数的数字小于零或者大于等于要格式化的指定对象的数目。
        /// </summary>
        /// <returns>result:2012-08-10</returns>
        public static string GetFromat_d()
        {
            try
            {
                return string.Format("{0:d}", dt);//2005-11-5 
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月10日</returns>
        public static string GetFromat_D()
        {
            try
            {
                return string.Format("{0:D}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月10日 14:23 </returns>
        public static string GetFromat_f()
        {
            try
            {
                return string.Format("{0:f}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月10日 14:23 </returns>
        public static string GetFromat_F()
        {
            try
            {
                return string.Format("{0:F}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012-08-10 14:23 </returns>
        public static string GetFromat_g()
        {
            try
            {
                return string.Format("{0:g}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012-08-10 14:23:23</returns>
        public static string GetFromat_G()
        {
            try
            {
                return string.Format("{0:G}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:08月10日</returns>
        public static string GetFromat_M()
        {
            try
            {
                return string.Format("{0:M}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:Fri,10 Aug 2010 14:06:25 GMT</returns>
        public static string GetFromat_R()
        {
            try
            {
                return string.Format("{0:R}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012-08-10T14:23:23</returns>
        public static string GetFromat_s()
        {
            try
            {
                return string.Format("{0:s}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:14:23</returns>
        public static string GetFromat_t()
        {
            try
            {
                return string.Format("{0:t}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:14:23:23</returns>
        public static string GetFromat_T()
        {
            try
            {
                return string.Format("{0:T}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012-08-10 14:23:23Z</returns>
        public static string GetFromat_u()
        {
            try
            {
                return string.Format("{0:u}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月10日 6:23:23</returns>
        public static string GetFromat_U()
        {
            try
            {
                return string.Format("{0:U}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月</returns>
        public static string GetFromat_Y()
        {
            try
            {
                return string.Format("{0:Y}", dt);
            }
            catch (Exception)
            {
                throw;
            }

        }
        /// <summary>
        /// </summary>
        /// <returns>result:2012年08月</returns>
        public static string GetFromat_yyyyMMddHHmmssffff()
        {
            try
            {
                return string.Format("{0:yyyyMMddHHmmssffff}", dt);
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本周第一天日期
        /// 星期天为第一天
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentWeekFirstDay()
        {
            try
            {
                return dt.AddDays(Convert.ToDouble(0 - Convert.ToInt16(dt.DayOfWeek)))
                    .ToString("yyyy-MM-dd");
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本周最后一天日期
        /// dt.AddDays(7).ToShortDateString();//7天后
        ///dt.AddDays(-7).ToShortDateString();7天前
        /// 周六为最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentWeekLastDay()
        {
            try
            {
                return dt.AddDays(Convert.ToDouble((6 - Convert.ToInt16(dt.DayOfWeek))))
                    .ToString("yyyy-MM-dd");
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 用数组处理获取本周当日为星期几
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentWeekDay()
        {
            try
            {
                string[] Day = new string[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
                return Day[Convert.ToInt16(dt.DayOfWeek)];
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取上周第一天日期
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeWeekFirstDay()
        {
            try
            {
                return dt.AddDays(Convert.ToDouble((0 - Convert.ToInt16(dt.DayOfWeek))) - 7).ToString("yyyy-MM-dd");

            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取上周最后一天日期
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeWeekLastDay()
        {
            try
            {
                return dt.AddDays(Convert.ToDouble((6 - Convert.ToInt16(dt.DayOfWeek))) - 7).ToString("yyyy-MM-dd");
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取下周第一天日期
        /// </summary>
        /// <returns></returns>
        public static string GetNextWeekFirstDay()
        {
            try
            {
                return dt.AddDays(Convert.ToDouble((0 - Convert.ToInt16(dt.DayOfWeek))) + 7).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取下周最后一天日期
        /// </summary>
        /// <returns></returns>
        public static string GetNextWeekLastDay()
        {
            try
            {
                return dt.AddDays(Convert.ToDouble((6 - Convert.ToInt16(dt.DayOfWeek))) + 7).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本个月的第一天
        /// dt.Year.ToString() + dt.Month.ToString() + "1";
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentMonthFirstDay()
        {
            try
            {
                //return dt.Year.ToString() + dt.Month.ToString() + "01";
                return dt.ToString("yyyy-MM-01");
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本个月的最后一天
        /// 这个处理有异常.
        /// DateTime.Parse(dt.Year.ToString() +
        /// dt.Month.ToString() + "1").AddMonths(1).AddDays(-1).ToShortDateString();
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentMonthLastDay()
        {
            try
            {
                //建议使用这个
                return DateTime.Parse(dt.ToString("yyyy-MM-01")).AddMonths(1).AddDays(-1).ToString("yyyy-MM-dd");
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取上个月的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeMonthFirstDay()
        {
            try
            {
                return DateTime.Parse(dt.ToString("yyyy-MM-01")).AddMonths(-1).ToString("yyyy-MM-01");
                //return dt.AddMonths(0 - ((dt.Month - 1) % 3)).ToString("yyyy-MM-01"); ;//与上面效果一样
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取上个月的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeMonthLastDay()
        {
            try
            {
                return DateTime.Parse(dt.ToString("yyyy-MM-01")).AddDays(-1).ToString("yyyy-MM-dd");
                //或者 return DateTime.Parse(dt.AddMonths(1 - ((dt.Month - 1) % 3)).ToString("yyyy-MM-01")).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取下个月的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetNextMonthFirstDay()
        {
            try
            {
                return DateTime.Parse(dt.ToString("yyyy-MM-01")).AddMonths(1).ToShortDateString();
                //或者return dt.AddMonths(2 - ((dt.Month - 1) % 3)).ToString("yyyy-MM-01");

            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取下个月的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetNextMonthLastDay()
        {
            try
            {
                return DateTime.Parse(dt.ToString("yyyy-MM-01")).AddMonths(2).AddDays(-1).ToShortDateString();
                //或者 return dt.AddMonths(2 - ((dt.Month - 1) % 3)).ToString("yyyy-MM-01");
                //或者return DateTime.Parse(dt.AddMonths(3 - ((dt.Month - 1) % 3)).ToString("yyyy-MM-01")).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本年的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentYearFirstDay()
        {
            try
            {
                //return DateTime.Parse(dt.ToString("yyyy-01-01")).ToShortDateString();
                return dt.ToString("yyyy-01-01");
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取本年的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentYearLastDay()
        {
            try
            {
                //return DateTime.Parse(dt.ToString("yyyy-01-01")).AddYears(1).AddDays(-1).ToShortDateString();
                //或者return DateTime.Parse(dt.AddMonths(6 - ((dt.Month - 1) % 3)).ToString("yyyy-MM-01")).AddDays(-1).ToShortDateString();
                return DateTime.Parse(dt.ToString("yyyy-01-01")).AddYears(1).AddDays(-1).ToString("yyyy-MM-dd");
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取去年的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeYearFirstDay()
        {
            try
            {
                return DateTime.Parse(dt.ToString("yyyy-01-01")).AddYears(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取去年的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetBeforeYearLastDay()
        {
            try
            {
                return DateTime.Parse(dt.ToString("yyyy-01-01")).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取明年的第一天
        /// </summary>
        /// <returns></returns>
        public static string GetNextYearFirstDay()
        {
            try
            {
                return DateTime.Parse(dt.ToString("yyyy-01-01")).AddYears(1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
        /// <summary>
        /// 获取明年的最后一天
        /// </summary>
        /// <returns></returns>
        public static string GetNextYearLastDay()
        {
            try
            {
                return DateTime.Parse(dt.ToString("yyyy-01-01")).AddYears(2).AddDays(-1).ToShortDateString();
            }
            catch (Exception)
            {
                throw;
            }
        }
    }
}
